{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7d389def-75f7-499e-a587-0e82b8bb636a",
   "metadata": {},
   "source": [
    "# Loading and rendering GLTF files\n",
    "You can [import meshes from GLTF](https://kaolin.readthedocs.io/en/latest/modules/kaolin.io.gltf.html) and render them and plug the renderer into Kaolin's [interactive renderer](https://kaolin.readthedocs.io/en/latest/modules/kaolin.visualize.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ab6e3188-0186-463b-b915-183067e90842",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0mNote: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install matplotlib --quiet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "938466b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import glob\n",
    "import math\n",
    "import copy\n",
    "import os\n",
    "\n",
    "import torch\n",
    "from matplotlib import pyplot as plt\n",
    "from tutorial_common import COMMON_DATA_DIR\n",
    "\n",
    "import kaolin as kal\n",
    "\n",
    "import nvdiffrast\n",
    "glctx = nvdiffrast.torch.RasterizeCudaContext(device='cuda')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87c3979b-e423-4a97-a836-0fc7517304a8",
   "metadata": {},
   "source": [
    "# Rendering function\n",
    "To use the interactive visualizer, we must implement a rendering function that take a camera as input.\n",
    "\n",
    "We first start with a base rendering function that will render a mesh given a camera and a light source represented as a [Spherical Gaussian](https://kaolin.readthedocs.io/en/latest/modules/kaolin.render.lighting.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8fb04630-79cd-4d61-a11b-a61aa90d6cf9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_pinhole_rays_dir(camera, height, width, device='cuda'):\n",
    "    \"\"\"Generate centered grid.\n",
    "    \n",
    "    This is a utility function for specular reflectance with spherical gaussian.\n",
    "    \"\"\"\n",
    "    pixel_y, pixel_x = torch.meshgrid(\n",
    "        torch.arange(height, device=device),\n",
    "        torch.arange(width, device=device),\n",
    "        indexing='ij'\n",
    "    )\n",
    "    pixel_x = pixel_x + 0.5  # scale and add bias to pixel center\n",
    "    pixel_y = pixel_y + 0.5  # scale and add bias to pixel center\n",
    "\n",
    "    # Account for principal point (offsets from the center)\n",
    "    pixel_x = pixel_x - camera.x0\n",
    "    pixel_y = pixel_y + camera.y0\n",
    "\n",
    "    # pixel values are now in range [-1, 1], both tensors are of shape res_y x res_x\n",
    "    # Convert to NDC\n",
    "    pixel_x = 2 * (pixel_x / width) - 1.0\n",
    "    pixel_y = 2 * (pixel_y / height) - 1.0\n",
    "\n",
    "    ray_dir = torch.stack((pixel_x * camera.tan_half_fov(kal.render.camera.intrinsics.CameraFOV.HORIZONTAL),\n",
    "                           -pixel_y * camera.tan_half_fov(kal.render.camera.intrinsics.CameraFOV.VERTICAL),\n",
    "                           -torch.ones_like(pixel_x)), dim=-1)\n",
    "\n",
    "    ray_dir = ray_dir.reshape(-1, 3)    # Flatten grid rays to 1D array\n",
    "    ray_orig = torch.zeros_like(ray_dir)\n",
    "\n",
    "    # Transform from camera to world coordinates\n",
    "    ray_orig, ray_dir = camera.extrinsics.inv_transform_rays(ray_orig, ray_dir)\n",
    "    ray_dir /= torch.linalg.norm(ray_dir, dim=-1, keepdim=True)\n",
    "\n",
    "    return ray_dir[0].reshape(1, height, width, 3)\n",
    "\n",
    "def base_render(camera, height, width, mesh, azimuth, elevation, amplitude, sharpness):\n",
    "    \"\"\"Base rendering function\"\"\"\n",
    "    vertices_camera = camera.extrinsics.transform(mesh.vertices)\n",
    "    vertices_clip = camera.intrinsics.project(vertices_camera)\n",
    "    face_vertices_camera = kal.ops.mesh.index_vertices_by_faces(\n",
    "        vertices_camera, mesh.faces)\n",
    "    faces_int = mesh.faces.int()\n",
    "    rast = nvdiffrast.torch.rasterize(\n",
    "        glctx, vertices_clip, faces_int,\n",
    "        (height, width), grad_db=False)\n",
    "    rast0 = torch.flip(rast[0], dims=(1,))\n",
    "    hard_mask = rast0[:, :, :, -1:] != 0\n",
    "    face_idx = (rast0[..., -1].long() - 1).contiguous()\n",
    "    coords = nvdiffrast.torch.interpolate(\n",
    "        vertices_camera, rast0, faces_int\n",
    "    )[0]\n",
    "    if mesh.has_or_can_compute_attribute('vertex_normals'):\n",
    "        im_base_normals = nvdiffrast.torch.interpolate(\n",
    "            mesh.vertex_normals, rast0, faces_int\n",
    "        )[0]\n",
    "    elif mesh.has_or_can_compute_attribute('normals') and mesh.has_attribute('face_normals_idx'):\n",
    "        im_base_normals = nvdiffrast.torch.interpolate(\n",
    "            mesh.normals, rast0, mesh.face_normals_idx.int()\n",
    "        )[0]\n",
    "    else:\n",
    "        raise KeyError(\"mesh has no normal information\")\n",
    "    vertices_ndc = kal.render.camera.intrinsics.down_from_homogeneous(vertices_clip)\n",
    "    face_vertices_ndc = kal.ops.mesh.index_vertices_by_faces(\n",
    "        vertices_ndc, mesh.faces\n",
    "    )\n",
    "    edges_dist0 = face_vertices_ndc[:, :, 1, :2] - face_vertices_ndc[:, :, 0, :2]\n",
    "    edges_dist1 = face_vertices_ndc[:, :, 2, :2] - face_vertices_ndc[:, :, 0, :2]\n",
    "    face_normal_sign = edges_dist0[..., 0] * edges_dist1[..., 1] - edges_dist1[..., 0] * edges_dist0[..., 1]\n",
    "\n",
    "    im_normal_sign = torch.sign(face_normal_sign[0, face_idx])\n",
    "    im_normal_sign[face_idx == -1] = 0.\n",
    "    im_base_normals *= im_normal_sign.unsqueeze(-1)\n",
    "\n",
    "    if mesh.uvs is not None:\n",
    "        uv_map = nvdiffrast.torch.interpolate(\n",
    "            mesh.uvs, rast0, mesh.face_uvs_idx.int()\n",
    "        )[0] % 1.\n",
    "        im_tangents = nvdiffrast.torch.interpolate(\n",
    "            mesh.vertex_tangents, rast0, faces_int\n",
    "        )[0]\n",
    "        im_bitangents = torch.nn.functional.normalize(\n",
    "            torch.cross(im_tangents, im_base_normals), dim=-1\n",
    "        )\n",
    "    im_material_idx = mesh.material_assignments[face_idx]\n",
    "    im_material_idx[face_idx == -1] = -1\n",
    "    albedo = torch.zeros((1, height, width, 3), device='cuda')\n",
    "    spec_albedo = torch.zeros((1, height, width, 3), device='cuda')\n",
    "    im_world_normals = torch.zeros((1, height, width, 3), device='cuda')\n",
    "    im_roughness = torch.zeros((1, height, width, 1), device='cuda')\n",
    "    for i, material in enumerate(mesh.materials):\n",
    "        mask = im_material_idx == i\n",
    "        if mesh.uvs is not None:\n",
    "            _texcoords = uv_map[mask]\n",
    "        if material.normals_texture is None:\n",
    "            im_world_normals[mask] = im_base_normals[mask]\n",
    "        else:\n",
    "            if _texcoords.shape[0] > 0:\n",
    "                perturbation_normal = nvdiffrast.torch.texture(\n",
    "                    material.normals_texture.unsqueeze(0),\n",
    "                    _texcoords.reshape(1, 1, -1, 2).contiguous(),\n",
    "                    filter_mode='linear'\n",
    "                )\n",
    "                shading_normals = torch.nn.functional.normalize(\n",
    "                    im_tangents[mask] * perturbation_normal[..., :1]\n",
    "                    - im_bitangents[mask] * perturbation_normal[..., 1:2]\n",
    "                    + im_base_normals[mask] * perturbation_normal[..., 2:3],\n",
    "                    dim=-1\n",
    "                )\n",
    "                im_world_normals[mask] = shading_normals\n",
    "\n",
    "        if material.diffuse_texture is None:\n",
    "            if material.diffuse_color is not None:\n",
    "                albedo[mask] = material.diffuse_color.unsqueeze(0)\n",
    "        else:\n",
    "            if _texcoords.shape[0] > 0:\n",
    "                pixel_val = nvdiffrast.torch.texture(\n",
    "                    material.diffuse_texture.unsqueeze(0),\n",
    "                    _texcoords.reshape(1, 1, -1, 2).contiguous(),\n",
    "                    filter_mode='linear'\n",
    "                )\n",
    "                albedo[mask] = pixel_val[0, 0]\n",
    "\n",
    "        if material.is_specular_workflow:\n",
    "            if material.specular_texture is None:\n",
    "                if material.specular_color is not None:\n",
    "                    spec_albedo[mask] = material.specular_color.unsqueeze(0)\n",
    "            else:\n",
    "                if _texcoords.shape[0] > 0:\n",
    "                    pixel_val = nvdiffrast.torch.texture(\n",
    "                        material.specular_texture.unsqueeze(0),\n",
    "                        _texcoords.reshape(1, 1, -1, 2).contiguous(),\n",
    "                        filter_mode='linear'\n",
    "                    )\n",
    "                    spec_albedo[mask] = pixel_val[0, 0]\n",
    "        else:\n",
    "            if material.metallic_texture is None:\n",
    "                if material.metallic_value is not None:\n",
    "                    spec_albedo[mask] = (1. - material.metallic_value) * 0.04 + \\\n",
    "                                        albedo[mask] * material.metallic_value\n",
    "                    albedo[mask] *= (1 - material.metallic_value)\n",
    "            else:\n",
    "                if _texcoords.shape[0] > 0:\n",
    "                    pixel_val = nvdiffrast.torch.texture(\n",
    "                        material.metallic_texture.unsqueeze(0),\n",
    "                        _texcoords.reshape(1, 1, -1, 2).contiguous(),\n",
    "                        filter_mode='nearest'\n",
    "                    )\n",
    "                    spec_albedo[mask] = (1. - pixel_val[0, 0]) * 0.04 + albedo[mask] * pixel_val[0, 0]\n",
    "                    albedo[mask] = albedo[mask] * (1. - pixel_val[0, 0])\n",
    "        if material.roughness_texture is None:\n",
    "            if material.roughness_value is not None:\n",
    "                im_roughness[mask] = torch.clamp(material.roughness_value.unsqueeze(0), 1e-3)\n",
    "        else:\n",
    "            if _texcoords.shape[0] > 0:\n",
    "                pixel_val = nvdiffrast.torch.texture(\n",
    "                    material.roughness_texture.unsqueeze(0),\n",
    "                    _texcoords.reshape(1, 1, -1, 2).contiguous(),\n",
    "                    filter_mode='linear'\n",
    "                )\n",
    "                im_roughness[mask] = torch.clamp(pixel_val[0, 0], 1e-3)\n",
    "            \n",
    "    img = torch.zeros((1, height, width, 3),\n",
    "                      dtype=torch.float, device='cuda')\n",
    "    sg_x, sg_y, sg_z = kal.ops.coords.spherical2cartesian(\n",
    "        azimuth, elevation)\n",
    "    directions = torch.stack(\n",
    "        [sg_y, sg_z, sg_x],\n",
    "        dim=-1\n",
    "    )\n",
    "    \n",
    "    _im_world_normals = torch.nn.functional.normalize(\n",
    "        im_world_normals[hard_mask.squeeze(-1)], dim=-1)\n",
    "    diffuse_effect = kal.render.lighting.sg_diffuse_inner_product(\n",
    "        amplitude, directions, sharpness,\n",
    "        _im_world_normals,\n",
    "        albedo[hard_mask.squeeze(-1)]\n",
    "    )\n",
    "    img[hard_mask.squeeze(-1)] = diffuse_effect\n",
    "    diffuse_img = torch.zeros_like(img)\n",
    "    diffuse_img[hard_mask.squeeze(-1)] = diffuse_effect\n",
    "\n",
    "    rays_d = generate_pinhole_rays_dir(camera, height, width)\n",
    "    specular_effect = kal.render.lighting.sg_warp_specular_term(\n",
    "        amplitude, directions, sharpness,\n",
    "        _im_world_normals,\n",
    "        im_roughness[hard_mask.squeeze(-1)].squeeze(-1),\n",
    "        -rays_d[hard_mask.squeeze(-1)],\n",
    "        spec_albedo[hard_mask.squeeze(-1)]\n",
    "    )\n",
    "    img[hard_mask.squeeze(-1)] += specular_effect\n",
    "    specular_img = torch.zeros_like(img)\n",
    "    specular_img[hard_mask.squeeze(-1)] = specular_effect\n",
    "\n",
    "    return {\n",
    "        'img': (torch.clamp(img[0], 0., 1.) * 255.).to(torch.uint8),\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d18717b0-d84e-4a7d-8f9c-1a067c0dd507",
   "metadata": {},
   "source": [
    "# Loading a mesh\n",
    "Now using [kaolin.io.gltf.import_mesh](https://kaolin.readthedocs.io/en/latest/modules/kaolin.io.gltf.html#kaolin.io.gltf.import_mesh) you can load this scene from the [GLTF sample models](https://github.com/KhronosGroup/glTF-Sample-Models/).\n",
    "\n",
    "With [SurfaceMesh class](https://kaolin.readthedocs.io/en/latest/modules/kaolin.rep.surface_mesh.html#kaolin.rep.SurfaceMesh) and [PBRMaterial class](https://kaolin.readthedocs.io/en/latest/modules/kaolin.io.materials.html#kaolin.io.materials.PBRMaterial) it's very easy to preprocess the data to be rendered. Finally we initialize a [Camera](https://kaolin.readthedocs.io/en/latest/modules/kaolin.render.camera.camera.html#kaolin.render.camera.Camera) to be used by the rendering function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "41eb96d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.8/site-packages/pygltflib/__init__.py:900: UserWarning: Conversion will leave Avocado.bin file orphaned since data is now in the GLTF object.\n",
      "  warnings.warn(f\"Conversion will leave {buffer.uri} file orphaned since data is now in the GLTF object.\")\n",
      "/opt/conda/lib/python3.8/site-packages/pygltflib/__init__.py:877: UserWarning: pygltflib currently unable to add image data to buffers.Please open an issue at https://gitlab.com/dodgyville/pygltflib/issues\n",
      "  warnings.warn(\"pygltflib currently unable to add image data to buffers.\"\n",
      "/kaolin/kaolin/io/gltf.py:266: UserWarning: The given buffer is not writable, and PyTorch does not support non-writable tensors. This means you can write to the underlying (supposedly non-writable) buffer using the tensor. You may want to copy the buffer to protect its data or make it writable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at ../torch/csrc/utils/tensor_new.cpp:1563.)\n",
      "  output = torch.frombuffer(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f3c547246d0>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "path = os.path.join(COMMON_DATA_DIR, 'meshes', 'gltf_avocado', 'Avocado.gltf')\n",
    "mesh = kal.io.gltf.import_mesh(path)\n",
    "\n",
    "mesh = mesh.cuda()\n",
    "mesh.materials = [mat.cuda().hwc().contiguous() for mat in mesh.materials]\n",
    "\n",
    "mesh.vertices = kal.ops.pointcloud.center_points(\n",
    "    mesh.vertices.unsqueeze(0), normalize=True).squeeze(0)\n",
    "\n",
    "azimuth = torch.zeros((1,), device='cuda')\n",
    "elevation = torch.full((1,), math.pi / 3., device='cuda')\n",
    "amplitude = torch.full((1, 3), 3., device='cuda')\n",
    "sharpness = torch.full((1,), 5., device='cuda')\n",
    "\n",
    "camera = kal.render.camera.Camera.from_args(\n",
    "    eye=torch.ones((3,), dtype=torch.float, device='cuda'),\n",
    "    at=torch.zeros((3,), dtype=torch.float, device='cuda'),\n",
    "    up=torch.tensor([0., 1., 0.], dtype=torch.float),\n",
    "    fov=math.pi * 45 / 180,\n",
    "    height=512, width=512,\n",
    "    near=0.1, far=10000.,\n",
    "    device='cuda'\n",
    ")\n",
    "\n",
    "def render(camera):\n",
    "    \"\"\"Render using camera dimension.\n",
    "    \n",
    "    This is the main function provided to the interactive visualizer\n",
    "    \"\"\"\n",
    "    output = base_render(camera, camera.height, camera.width, mesh,\n",
    "                         azimuth, elevation, amplitude, sharpness)\n",
    "    return output\n",
    "    \n",
    "def lowres_render(camera):\n",
    "    \"\"\"Render with lower dimension.\n",
    "    \n",
    "    This function will be used as a \"fast\" rendering used when the mouse is moving to avoid slow down.\n",
    "    \"\"\"\n",
    "    output = base_render(camera, int(camera.height / 4), int(camera.width / 4), mesh,\n",
    "                         azimuth, elevation, amplitude, sharpness)\n",
    "    return output\n",
    "\n",
    "output = render(camera)\n",
    "plt.figure()\n",
    "plt.imshow(output['img'].cpu().numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2023c19-0b6c-4aef-a491-0fa8b29fd5c0",
   "metadata": {},
   "source": [
    "# Interactive visualizer\n",
    "We can now plug the camera and the renderer into the interactive visualizer, adding some ipywidgets interactive sliders to modify lighting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "091083de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "55ce925b78fc468396d3b1ab96e9e36e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(Canvas(height=512, width=512), interactive(children=(FloatSlider(value=1.0471975803375244, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b058ce69d3274e4b928d61f0770e4b8e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from ipywidgets import interactive, HBox, FloatSlider\n",
    "\n",
    "visualizer = kal.visualize.IpyTurntableVisualizer(\n",
    "    512, 512, copy.deepcopy(camera), render, fast_render=lowres_render, \n",
    "    max_fps=5, world_up_axis=1,\n",
    ")\n",
    "\n",
    "def sliders_callback(new_elevation, new_azimuth, new_amplitude, new_sharpness):\n",
    "    \"\"\"ipywidgets sliders callback\"\"\"\n",
    "    with visualizer.out: # This is in case of bug\n",
    "        elevation[:] = new_elevation\n",
    "        azimuth[:] = new_azimuth\n",
    "        amplitude[:] = new_amplitude\n",
    "        sharpness[:] = new_sharpness\n",
    "        # this is how we request a new update\n",
    "        visualizer.render_update()\n",
    "        \n",
    "elevation_slider = FloatSlider(\n",
    "    value=elevation.item(),\n",
    "    min=-math.pi / 2.,\n",
    "    max=math.pi / 2.,\n",
    "    step=0.1,\n",
    "    description='Elevation:',\n",
    "    continuous_update=True,\n",
    "    readout=True,\n",
    "    readout_format='.1f',\n",
    ")\n",
    "\n",
    "azimuth_slider = FloatSlider(\n",
    "    value=azimuth.item(),\n",
    "    min=-math.pi,\n",
    "    max=math.pi,\n",
    "    step=0.1,\n",
    "    description='Azimuth:',\n",
    "    continuous_update=True,\n",
    "    readout=True,\n",
    "    readout_format='.1f',\n",
    ")\n",
    "\n",
    "amplitude_slider = FloatSlider(\n",
    "    value=amplitude[0,0].item(),\n",
    "    min=0.1,\n",
    "    max=40.,\n",
    "    step=0.1,\n",
    "    description='Amplitude:\\n',\n",
    "    continuous_update=True,\n",
    "    readout=True,\n",
    "    readout_format='.1f',\n",
    ")\n",
    "\n",
    "sharpness_slider = FloatSlider(\n",
    "    value=sharpness.item(),\n",
    "    min=0.1,\n",
    "    max=20.,\n",
    "    step=0.1,\n",
    "    description='Sharpness:\\n',\n",
    "    continuous_update=True,\n",
    "    readout=True,\n",
    "    readout_format='.1f',\n",
    ")\n",
    "\n",
    "interactive_slider = interactive(\n",
    "    sliders_callback,\n",
    "    new_elevation=elevation_slider,\n",
    "    new_azimuth=azimuth_slider,\n",
    "    new_amplitude=amplitude_slider,\n",
    "    new_sharpness=sharpness_slider\n",
    ")\n",
    "\n",
    "# We combine all the widgets and the visualizer canvas and output in a single display\n",
    "full_output = HBox([visualizer.canvas, interactive_slider])\n",
    "display(full_output, visualizer.out)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
